package com.factory.rental.controller;

import com.factory.rental.common.PageResult;
import com.factory.rental.common.PageSupport;
import com.factory.rental.common.Result;
import com.factory.rental.dto.PriceDTO;
import com.factory.rental.model.Price;
import com.factory.rental.service.PriceService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

/**
 * 价格策略控制器
 * 提供价格策略的CRUD操作和其他相关API
 */
@RestController
@RequestMapping("/prices")
public class PriceController {

    private final PriceService priceService;

    @Autowired
    public PriceController(PriceService priceService) {
        this.priceService = priceService;
    }

    /**
     * 创建价格策略
     * @param priceDTO 价格策略DTO
     * @return 创建后的价格策略
     */
    @PostMapping("save")
    public Result<Price> createPrice(@RequestBody PriceDTO priceDTO) {
        Price savedPrice = priceService.savePrice(priceDTO);
        return Result.success(savedPrice, "价格策略创建成功");
    }

    /**
     * 根据ID获取价格策略
     * @param id 价格策略ID
     * @return 价格策略
     */
    @GetMapping("/{id}")
    public Result<Price> getPriceById(@PathVariable Long id) {
        Optional<Price> price = priceService.getPriceById(id);
        if (price.isPresent()) {
            return Result.success(price.get());
        } else {
            return Result.error(404, "未找到指定ID的价格策略");
        }
    }

    /**
     * 根据类型获取价格策略列表
     * @param type 价格类型
     * @return 价格策略列表
     */
    @GetMapping("/type/{type}")
    public Result<List<Price>> getPricesByType(@PathVariable Price.PriceType type) {
        List<Price> prices = priceService.getPricesByType(type);
        return Result.success(prices);
    }

    /**
     * 根据房间类型获取价格策略列表
     * @param roomType 房间类型
     * @return 价格策略列表
     */
    @GetMapping("/room-type/{roomType}")
    public Result<List<Price>> getPricesByRoomType(@PathVariable String roomType) {
        List<Price> prices = priceService.getPricesByRoomType(roomType);
        return Result.success(prices);
    }

    /**
     * 获取所有价格策略（分页）
     * @param page 页码
     * @param size 每页数量
     * @return 分页后的价格策略列表
     */
    @GetMapping("pageList")
    public PageResult<Price> getAllPrices(
            @RequestParam(defaultValue = "1") int page,
            @RequestParam(defaultValue = "10") int size) {
        Pageable pageable = PageSupport.ofPage(page, size);
        Page<Price> prices = priceService.getAllPrices(pageable);
        return PageResult.success(prices);
    }

    /**
     * 更新价格策略
     * @param id 价格策略ID
     * @param priceDTO 价格策略DTO
     * @return 更新后的价格策略
     */
    @PutMapping("/{id}")
    public Result<Price> updatePrice(@PathVariable Long id, @RequestBody PriceDTO priceDTO) {
        try {
            Price updatedPrice = priceService.updatePrice(id, priceDTO);
            return Result.success(updatedPrice, "价格策略更新成功");
        } catch (RuntimeException e) {
            return Result.error(404, "未找到指定ID的价格策略");
        }
    }

    /**
     * 删除价格策略
     * @param id 价格策略ID
     * @return 删除结果
     */
    @DeleteMapping("/{id}")
    public Result<Void> deletePrice(@PathVariable Long id) {
        try {
            priceService.deletePrice(id);
            return Result.success(null, "价格策略删除成功");
        } catch (RuntimeException e) {
            return Result.error(404, "未找到指定ID的价格策略");
        }
    }

    /**
     * 更新价格策略状态
     * @param id 价格策略ID
     * @param enabled 是否启用
     * @return 更新结果
     */
    @PutMapping("/{id}/status/{enabled}")
    public Result<Void> updatePriceStatus(@PathVariable Long id, @PathVariable boolean enabled) {
        try {
            priceService.updatePriceStatus(id, enabled);
            return Result.success(null, "价格策略状态更新成功");
        } catch (RuntimeException e) {
            return Result.error(404, "未找到指定ID的价格策略");
        }
    }

    /**
     * 获取有效的价格策略
     * @return 有效的价格策略列表
     */
    @GetMapping("/effective")
    public Result<List<Price>> getEffectivePrices() {
        List<Price> prices = priceService.getEffectivePrices();
        return Result.success(prices);
    }

    /**
     * 计算房间的费用
     * @param roomId 房间ID
     * @param days 天数
     * @param priceType 价格类型
     * @return 费用金额
     */
    @GetMapping("/calculate-cost")
    public Result<BigDecimal> calculateCost(
            @RequestParam Long roomId,
            @RequestParam int days,
            @RequestParam Price.PriceType priceType) {
        try {
            BigDecimal cost = priceService.calculateCost(roomId, days, priceType);
            return Result.success(cost, "费用计算成功");
        } catch (RuntimeException e) {
            return Result.error(400, e.getMessage());
        }
    }

    /**
     * 获取费用分析数据
     * @return 费用分析数据
     */
    @GetMapping("/cost-analysis")
    public Result<List<PriceService.PriceAnalysisDTO>> getCostAnalysis() {
        List<PriceService.PriceAnalysisDTO> analysis = priceService.getCostAnalysis();
        return Result.success(analysis, "费用分析数据获取成功");
    }
}